package com.example.justbuy.service.Impl;

import com.example.justbuy.service.WorkflowService;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.springframework.stereotype.Service;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class WorkflowServiceImpl implements WorkflowService{
    ProcessEngine processEngine=ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程
     */
    @Override
    @Test
    public void saveNewDeploye() {
        InputStream inputStreambpmn = this.getClass().getResourceAsStream("/bpmn/check.bpmn");
        InputStream inputStreampng = this.getClass().getResourceAsStream("/bpmn/check.png");
        processEngine.getRepositoryService()//
                .createDeployment()//创建一个部署对象
                .name("审核流程")//添加部署的名称
                .addInputStream("check.bpmn", inputStreambpmn)//使用资源文件的名称（要求：与资源文件的名称要一致），和输入流完成部署
                .addInputStream("check.png", inputStreampng)//使用资源文件的名称（要求：与资源文件的名称要一致），和输入流完成部署
                .deploy();//完成部署
    }

    /**
     *启动流程
     * @return 返回流程id
     */
    @Override
    public String startProcessInstance(){
        //流程定义的key
        ProcessInstance pi = processEngine.getRuntimeService()//
                .startProcessInstanceByKey("myProcess_1");
        return pi.getId();
    }

    /**
     *根据任务id获得流程id
     * @return 返回流程id
     */
    @Override
    public String getProcessInstanceid(String taskId){
        //流程定义的key
        Task task=processEngine.getTaskService().createTaskQuery() // 创建任务查询
                .taskId(taskId) // 根据任务id查询
                .singleResult();
        return task.getProcessInstanceId();
    }

    /**
     * 设置流程类型 并完成任务
     * @param taskId 任务id
     * @param typename 流程类型的名称（入驻，活动，商品）
     */
    @Override
    public void finshTask(String taskId,String typename){
        //完成任务的同时，设置流程变量，让流程变量判断连线该如何执行
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("typename", typename);
        processEngine.getTaskService()//
                .complete(taskId,variables);
    }


    /**
     *设置流程的任务执行人
     * @param assignee 任务执行人
     * @param did 流程id
     */
    @Override
    public void updeAssignee(String assignee,String did){
        List<Task> tasks = processEngine.getTaskService().createTaskQuery().processInstanceId(did).list();
        for (Task task : tasks) {
            processEngine.getTaskService().claim(task.getId(),assignee);
        }
    }

    /**
     * 根据流程类型获取所以任务
     * @param typename 流程类型的名称（入驻，活动，商品）
     * @return 所有相关的任务
     */
    @Override
    public List<Task> getTasks(String typename){
        List<Task> list=processEngine.getTaskService().createTaskQuery().taskName(typename).list();
        return list;
    }

    /**
     *设置流程的变量
     * @param taskId 任务id
     * @param typename 连线类型
     * @param map 保存变量
     */
    @Override
    public void completeTask(String taskId,String typename,Map<String,Object> map){
        //完成任务的同时，设置流程变量，让流程变量判断连线该如何执行
        processEngine.getTaskService().setVariables(taskId,map);
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("typename", typename);
        processEngine.getTaskService()//
                .complete(taskId,variables);
        System.out.println("完成任务："+taskId);
    }

    /**
     *获取流程变量
     * @param taskId 任务id
     * @return 工作流变量
     */
    @Override
    public Map<String, Object> getVariablesByTask(String taskId){
        Map<String, Object> map = processEngine.getTaskService().getVariables(taskId);
        return map;
    }

    /**
     * 获取任务id
     * @param did 流程id
     * @param taskName 任务名称(用户申请，商家审核，活动审核，商品审核，发送请求结果)
     * @return 任务id
     */
    @Override
    public String getTaskid(String did,String taskName){
        Task task=processEngine.getTaskService().createTaskQuery()
                .processInstanceId(did).taskName(taskName)
                .singleResult();
        return task.getId();
    }
//    /**查询部署对象信息，对应表（act_re_deployment）*/
//    @Override
//    public List<Deployment> findDeploymentList() {
//        List<Deployment> list = processEngine.getRepositoryService().createDeploymentQuery()//创建部署对象查询
//                .orderByDeploymenTime().asc()//
//                .list();
//        return list;
//    }
//
//    /**查询流程定义的信息，对应表（act_re_procdef）*/
//    @Override
//    public List<ProcessDefinition> findProcessDefinitionList() {
//        List<ProcessDefinition> list = processEngine.getRepositoryService().createProcessDefinitionQuery()//创建流程定义查询
//                .orderByProcessDefinitionVersion().asc()//
//                .list();
//        return list;
//    }
//
//    /**使用部署对象ID和资源图片名称，获取图片的输入流*/
//    @Override
//    public InputStream findImageInputStream(String deploymentId,String imageName) {
//        return processEngine.getRepositoryService().getResourceAsStream(deploymentId, imageName);
//    }
//
//    /**使用部署对象ID，删除流程定义*/
//    @Override
//    public void deleteProcessDefinitionByDeploymentId(String deploymentId) {
//        processEngine.getRepositoryService().deleteDeployment(deploymentId, true);
//    }

}
